/*******************************************************************************
 * File Name          : usb_bot.c
 * Author             : Brian
 * Date               : 01-Oct-2011
 * Description        : Mass Storage demo main file
 *
 * Original version of this project comes from the STM32 USB FS dev library
 * mass storage example (V3.3.0 21-March-2011). Minor modifications were made 
 * to work with miniSTM32 board.
 */

#include "usb_scsi.h"
#include "hw_config.h"
#include "usb_regs.h"
#include "usb_mem.h"
#include "usb_conf.h"
#include "usb_bot.h"
#include "memory.h"
#include "usb_lib.h"

uint8_t Bot_State;
uint8_t Bulk_Data_Buff[BULK_MAX_PACKET_SIZE];  /* data buffer*/
uint16_t Data_Len;
Bulk_Only_CBW CBW;
Bulk_Only_CSW CSW;
uint32_t SCSI_LBA , SCSI_BlkLen;
extern uint32_t Max_Lun;

/*******************************************************************************
 * Function Name  : Mass_Storage_In
 * Description    : Mass Storage IN transfer.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 */
void Mass_Storage_In (void)
{
	switch (Bot_State)
	{
		case BOT_CSW_Send:
		case BOT_ERROR:
			Bot_State = BOT_IDLE;
			/* enable the Endpoint to receive the next cmd*/
			SetEPRxStatus(ENDP2, EP_RX_VALID);
			break;

		case BOT_DATA_IN:
			switch (CBW.CB[0])
			{
				case SCSI_READ10:
					SCSI_Read10_Cmd(CBW.bLUN , SCSI_LBA , SCSI_BlkLen);
					break;
			}
			break;

		case BOT_DATA_IN_LAST:
			Set_CSW (CSW_CMD_PASSED, SEND_CSW_ENABLE);
			SetEPRxStatus(ENDP2, EP_RX_VALID);
			break;
	
		default:
			break;
	}
}

/*******************************************************************************
 * Function Name  : Mass_Storage_Out
 * Description    : Mass Storage OUT transfer.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 */
void Mass_Storage_Out (void)
{
	uint8_t CMD;
	CMD = CBW.CB[0];
	
	Data_Len = USB_SIL_Read(EP2_OUT, Bulk_Data_Buff);
	
	switch (Bot_State)
	{
		case BOT_IDLE:
			CBW_Decode();
			break;

		case BOT_DATA_OUT:
			if (CMD == SCSI_WRITE10)
			{
				SCSI_Write10_Cmd(CBW.bLUN , SCSI_LBA , SCSI_BlkLen);
				break;
			}
			Bot_Abort(DIR_OUT);
			Set_Scsi_Sense_Data(CBW.bLUN, ILLEGAL_REQUEST, 
				INVALID_FIELED_IN_COMMAND);
			Set_CSW (CSW_PHASE_ERROR, SEND_CSW_DISABLE);
			break;

		default:
			Bot_Abort(BOTH_DIR);
			Set_Scsi_Sense_Data(CBW.bLUN, ILLEGAL_REQUEST, 
				INVALID_FIELED_IN_COMMAND);
			Set_CSW (CSW_PHASE_ERROR, SEND_CSW_DISABLE);
			break;
	}
}

/*******************************************************************************
 * Function Name  : CBW_Decode
 * Description    : Decode the received CBW and call the related SCSI command
 *                 routine.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 */
void CBW_Decode(void)
{
	uint32_t Counter;
	
	for (Counter = 0; Counter < Data_Len; Counter++)
		*((uint8_t *)&CBW + Counter) = Bulk_Data_Buff[Counter];

	CSW.dTag = CBW.dTag;
	CSW.dDataResidue = CBW.dDataLength;

	if (Data_Len != BOT_CBW_PACKET_LENGTH)
	{
		Bot_Abort(BOTH_DIR);
		/* reset the CBW.dSignature to disable the clear feature until 
		 * receiving a Mass storage reset
		 */
		CBW.dSignature = 0;
		Set_Scsi_Sense_Data(CBW.bLUN, ILLEGAL_REQUEST, 
			PARAMETER_LIST_LENGTH_ERROR);
		Set_CSW (CSW_CMD_FAILED, SEND_CSW_DISABLE);
		return;
	}
	
	if ((CBW.CB[0] == SCSI_READ10 ) || (CBW.CB[0] == SCSI_WRITE10 ))
	{
		/* Calculate Logical Block Address */
		SCSI_LBA = (CBW.CB[2] << 24) | (CBW.CB[3] << 16) | (CBW.CB[4] <<  8) 
			| CBW.CB[5];
		/* Calculate the Number of Blocks to transfer */
		SCSI_BlkLen = (CBW.CB[7] <<  8) | CBW.CB[8];
	}
	
	if (CBW.dSignature == BOT_CBW_SIGNATURE)
	{
		/* Valid CBW */
		if ((CBW.bLUN > Max_Lun) || (CBW.bCBLength < 1) || (CBW.bCBLength > 16))
		{
			Bot_Abort(BOTH_DIR);
			Set_Scsi_Sense_Data(CBW.bLUN, ILLEGAL_REQUEST, 
				INVALID_FIELED_IN_COMMAND);
			Set_CSW (CSW_CMD_FAILED, SEND_CSW_DISABLE);
		}
		else
		{
			switch (CBW.CB[0])
			{
				case SCSI_REQUEST_SENSE:
					SCSI_RequestSense_Cmd (CBW.bLUN);
					break;
				case SCSI_INQUIRY:
					SCSI_Inquiry_Cmd(CBW.bLUN);
					break;
				case SCSI_START_STOP_UNIT:
					SCSI_Start_Stop_Unit_Cmd(CBW.bLUN);
					break;
				case SCSI_ALLOW_MEDIUM_REMOVAL:
					SCSI_Start_Stop_Unit_Cmd(CBW.bLUN);
					break;
				case SCSI_MODE_SENSE6:
					SCSI_ModeSense6_Cmd (CBW.bLUN);
					break;
				case SCSI_MODE_SENSE10:
					SCSI_ModeSense10_Cmd (CBW.bLUN);
					break;
				case SCSI_READ_FORMAT_CAPACITIES:
					SCSI_ReadFormatCapacity_Cmd(CBW.bLUN);
					break;
				case SCSI_READ_CAPACITY10:
					SCSI_ReadCapacity10_Cmd(CBW.bLUN);
					break;
				case SCSI_TEST_UNIT_READY:
					SCSI_TestUnitReady_Cmd(CBW.bLUN);
					break;
				case SCSI_READ10:
					SCSI_Read10_Cmd(CBW.bLUN, SCSI_LBA , SCSI_BlkLen);
					break;
				case SCSI_WRITE10:
					SCSI_Write10_Cmd(CBW.bLUN, SCSI_LBA , SCSI_BlkLen);
					break;
				case SCSI_VERIFY10:
					SCSI_Verify10_Cmd(CBW.bLUN);
					break;
				case SCSI_FORMAT_UNIT:
					SCSI_Format_Cmd(CBW.bLUN);
					break;
				
				/*Unsupported command*/
	
				case SCSI_MODE_SELECT10:
					SCSI_Mode_Select10_Cmd(CBW.bLUN);
					break;
				case SCSI_MODE_SELECT6:
					SCSI_Mode_Select6_Cmd(CBW.bLUN);
					break;
				case SCSI_SEND_DIAGNOSTIC:
					SCSI_Send_Diagnostic_Cmd(CBW.bLUN);
					break;
				case SCSI_READ6:
					SCSI_Read6_Cmd(CBW.bLUN);
					break;
				case SCSI_READ12:
					SCSI_Read12_Cmd(CBW.bLUN);
					break;
				case SCSI_READ16:
					SCSI_Read16_Cmd(CBW.bLUN);
					break;
				case SCSI_READ_CAPACITY16:
					SCSI_READ_CAPACITY16_Cmd(CBW.bLUN);
					break;
				case SCSI_WRITE6:
					SCSI_Write6_Cmd(CBW.bLUN);
					break;
				case SCSI_WRITE12:
					SCSI_Write12_Cmd(CBW.bLUN);
					break;
				case SCSI_WRITE16:
					SCSI_Write16_Cmd(CBW.bLUN);
					break;
				case SCSI_VERIFY12:
					SCSI_Verify12_Cmd(CBW.bLUN);
					break;
				case SCSI_VERIFY16:
					SCSI_Verify16_Cmd(CBW.bLUN);
					break;
	
				default:
				{
					Bot_Abort(BOTH_DIR);
					Set_Scsi_Sense_Data(CBW.bLUN, ILLEGAL_REQUEST, 
						INVALID_COMMAND);
					Set_CSW (CSW_CMD_FAILED, SEND_CSW_DISABLE);
				}
			}
		}
	}
	else
	{
		/* Invalid CBW */
		Bot_Abort(BOTH_DIR);
		Set_Scsi_Sense_Data(CBW.bLUN, ILLEGAL_REQUEST, INVALID_COMMAND);
		Set_CSW (CSW_CMD_FAILED, SEND_CSW_DISABLE);
	}
}

/*******************************************************************************
 * Function Name  : Transfer_Data_Request
 * Description    : Send the request response to the PC HOST.
 * Input          : uint8_t* Data_Address : point to the data to transfer.
 *                  uint16_t Data_Length : the number of Bytes to transfer.
 * Output         : None.
 * Return         : None.
 */
void Transfer_Data_Request(uint8_t* Data_Pointer, uint16_t Data_Len)
{
	USB_SIL_Write(EP1_IN, Data_Pointer, Data_Len);

	SetEPTxStatus(ENDP1, EP_TX_VALID);
	Bot_State = BOT_DATA_IN_LAST;
	CSW.dDataResidue -= Data_Len;
	CSW.bStatus = CSW_CMD_PASSED;
}

/*******************************************************************************
 * Function Name  : Set_CSW
 * Description    : Set the SCW with the needed fields.
 * Input          : uint8_t CSW_Status this filed can be CSW_CMD_PASSED,
 *					CSW_CMD_FAILED, or CSW_PHASE_ERROR.
 * Output         : None.
 * Return         : None.
 */
void Set_CSW (uint8_t CSW_Status, uint8_t Send_Permission)
{
	CSW.dSignature = BOT_CSW_SIGNATURE;
	CSW.bStatus = CSW_Status;
	
	USB_SIL_Write(EP1_IN, ((uint8_t *)& CSW), CSW_DATA_LENGTH);
	
	Bot_State = BOT_ERROR;
	if (Send_Permission)
	{
		Bot_State = BOT_CSW_Send;
		SetEPTxStatus(ENDP1, EP_TX_VALID);
	}
}

/*******************************************************************************
 * Function Name  : Bot_Abort
 * Description    : Stall the needed Endpoint according to the selected direction.
 * Input          : Endpoint direction IN, OUT or both directions
 * Output         : None.
 * Return         : None.
 */
void Bot_Abort(uint8_t Direction)
{
	switch (Direction)
	{
		case DIR_IN :
			SetEPTxStatus(ENDP1, EP_TX_STALL);
			break;
		case DIR_OUT :
			SetEPRxStatus(ENDP2, EP_RX_STALL);
			break;
		case BOTH_DIR :
			SetEPTxStatus(ENDP1, EP_TX_STALL);
			SetEPRxStatus(ENDP2, EP_RX_STALL);
			break;
		default:
			break;
	}
}

/**** END OF FILE ****/
